package collection;

import java.util.Arrays;
import java.util.Iterator;

public class MyArrayList implements Iterable<Integer> {
    private int[] data; //用来存放数据
    private int initCapacity; //初始的容量
    private int size; //数据的数量

    public MyArrayList() {
        this(10); //默认初始容量是10
    }

    public MyArrayList(int initCapacity) {
        this.initCapacity = initCapacity; //可以任意指定初始容量
        this.data = new int[0]; //先初始化一个0长度数组(为了不占内存)，第一次添加数据时才创建initCapacity长度的数组
    }

    public void add(int value) {
        ensureCapacity(); //确认数组容量，如果数组容量不足，1.5倍扩容
        data[size] = value; //size总是指向数据后面的一个空位置
        size++;
    }

    private void ensureCapacity() {
        if (data.length == 0) { //最初初始化的0长度数组
            data = new int[this.initCapacity]; //重新初始化一个initCapacity长度的数组
            return;
        }
        if (size >= data.length) { //数组已经放满
            //新长度是原来的1.5倍，+  >>，加号会先运算，后面括号括起来让>>先运算
            int newCapacity = data.length + (data.length >> 1); //右移1位运算相当于除2
            this.data = Arrays.copyOf(data, newCapacity); //原数组复制出一个新的数组
        }
    }

    public void remove(int index) {
        jianChaXiaBiao(index); //检查下标有没有越界
        if (index == size - 1) { //删除size前面一个位置
            size--; //直接向前移动size
            return;
        }
        //删除前面的数据，index+1到size-1位置的数据，向前复制一位
        System.arraycopy(data, index + 1, data, index, size - index - 1);
        size--; //数据数量减1
    }

    public int get(int index) {
        jianChaXiaBiao(index); //检测下标有没有越界
        return data[index];
    }

    private void jianChaXiaBiao(int index) {
        if (index < 0 || index >= size) { //访问的位置超出下标范围
            throw new IndexOutOfBoundsException("下标越界");
        }
    }

    public void set(int index, int value) {
        jianChaXiaBiao(index); //检测下标有没有越界
        data[index] = value; //把index位置的值替换成新的值
    }

    public int size() {
        return this.size; //返回添加的数据数量
    }

    //迭代器
    //新建一个迭代器对象，用来对当前列表进行迭代遍历
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int index = 0;

            //index<size,有下一个
            //index>=size,没有下一个
            @Override
            public boolean hasNext() {
                return index < size;
            }

            //取index位置的值，然后index向后移动
            @Override
            public Integer next() {
                int tmp = data[index];
                index++;
                return tmp;
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException("不支持删除");
            }
        };
    }

    public static void main(String[] args) {
        MyArrayList list = new MyArrayList();
        for (int i = 0; i < 18; i++) {
            list.add(i);
        }

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        System.out.println("------------------");

        list.remove(5);
        list.remove(12);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        System.out.println("------------------");

        list.set(10, 999);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        System.out.println("------------------");

        Iterator<Integer> it = list.iterator();
        while (it.hasNext()) {
            Integer v = it.next();
            System.out.println(v);
        }

        System.out.println("------------------");

        //相当于上面写的用迭代器遍历输出集合
        for (Integer a : list) {
            System.out.println(a);
        }
    }
}

/*
    java.util.Iterator
    随集合框架在JDK1.2中出现

    java.util.Iterable
    在JDK1.5中随着foreach遍历语法出现，凡是Iterable的子类型，都可以使用foreach语法
*/
